home *** CD-ROM | disk | FTP | other *** search
/ PC User 2003 December / Australian PC User - December 2003 (CD2).iso / software / apps / files / dwmx2k4.exe / Disk1 / data1.cab / Configuration_En / Components / Common / SignatureBuilder.js < prev    next >
Encoding:
JavaScript  |  2003-09-05  |  23.5 KB  |  775 lines
  1. // Copyright 2001, 2002, 2003 Macromedia, Inc. All rights reserved.
  2.  
  3. //*-------------------------------------------------------------------
  4. // FUNCTION:
  5. //  getPrimitiveTypeSignature
  6. //
  7. // DESCRIPTION:
  8. //    returns the signature for primitive types for that server model
  9. //
  10. // ARGUMENTS:
  11. //    languageSignature : language signature string
  12. //  aType             : Primitive type
  13. //    
  14. // RETURNS:
  15. //   String
  16. //--------------------------------------------------------------------
  17.  
  18. function getPrimitiveTypeSignature(languageSignature, aType)
  19. {
  20.  
  21.   // do a lookup and return the language-specific string
  22.   if(languageSignature && aType)
  23.   {
  24.     aDataType = languageSignature.PrimitiveTypes[aType];
  25.     if(aDataType)
  26.     {
  27.       return aDataType;
  28.     }
  29.   }
  30.   return "unknown";
  31. }
  32.  
  33. //*-------------------------------------------------------------------
  34. // FUNCTION:
  35. //  getTypeSignature
  36. //
  37. // DESCRIPTION:
  38. //    returns the type signature by evaluating it for that server model
  39. //
  40. // ARGUMENTS:
  41. //    languageSignature       : language signature string
  42. //  typeSignatureDescriptor : type descriptor string
  43. //    
  44. // RETURNS:
  45. //   String
  46. //--------------------------------------------------------------------
  47.  
  48. function getTypeSignature(languageSignature, typeSignatureDescriptor)
  49. {
  50.   var typeString;
  51.   if (typeSignatureDescriptor)
  52.   {
  53.     if (typeSignatureDescriptor.hasChildNodes())
  54.     {
  55.       //check for indirection nodes;
  56.       var indirectionsnodes = typeSignatureDescriptor.childNodes[0];
  57.       if(indirectionsnodes != null)
  58.       {
  59.         var indirectionnodes  = indirectionsnodes.hasChildNodes();
  60.         if(indirectionnodes)
  61.         {
  62.           for (var i=0; i < indirectionnodes.childNodes.length; i++)
  63.           {
  64.             // todo
  65.           }
  66.         }
  67.       }
  68.     }
  69.     else
  70.     {
  71.       typeString = typeSignatureDescriptor.type;
  72.       if (typeSignatureDescriptor.primitive == "true")
  73.       {
  74.         typeString = getPrimitiveTypeSignature(languageSignature,typeString);
  75.       }
  76.       if(typeSignatureDescriptor.array == "true")
  77.       {
  78.         var arraySignature = languageSignature.Array;
  79.         var arrayPattern = /\$\$ARRAYNAME/g;
  80.         arraySignature = arraySignature.replace(arrayPattern, typeString);
  81.         if(typeSignatureDescriptor.rank)
  82.         {
  83.           var rank = parseInt(typeSignatureDescriptor.rank);
  84.           if(rank > 1)
  85.           {
  86.             var arrayBracket = languageSignature.ArrayBracket;
  87.             for(var i = 0; i < rank - 1; i++)
  88.             {
  89.                 arraySignature = arraySignature + arrayBracket;
  90.             }
  91.           }
  92.         }
  93.         typeString = arraySignature;
  94.       }
  95.     }
  96.   }
  97.   return typeString;
  98. }
  99.  
  100. //*-------------------------------------------------------------------
  101. // FUNCTION:
  102. //  getMethodTemplate
  103. //
  104. // DESCRIPTION:
  105. //    returns the method template for that server model
  106. //
  107. // ARGUMENTS:
  108. //    languageSignature : language signature string
  109. //  isConstructor     : boolean to indicate whether the method is a 
  110. //                      constructor or not
  111. //    
  112. // RETURNS:
  113. //   String
  114. //--------------------------------------------------------------------
  115.  
  116. function getMethodTemplate(languageSignature, isConstructor)
  117. {
  118.   if(languageSignature)
  119.   {
  120.     if(isConstructor)
  121.     {
  122.       return languageSignature.Constructor;
  123.     }
  124.     return languageSignature.Method;
  125.   }
  126. }
  127.  
  128. //*-------------------------------------------------------------------
  129. // FUNCTION:
  130. //  getDropMethodSignature
  131. //
  132. // DESCRIPTION:
  133. //    returns the method signature that gets dropped for that server model
  134. //
  135. // ARGUMENTS:
  136. //    languageSignature : language signature string
  137. //  methodDescriptor  : method descriptor string
  138. //    
  139. // RETURNS:
  140. //   String
  141. //--------------------------------------------------------------------
  142.  
  143. function getDropMethodSignature(languageSignature, methodDescriptor, objectName)
  144. {
  145.   var methodInfo = "";
  146.   var methodCall = "";
  147.   var throwsCall = "";
  148.   var argumentsString="";
  149.   var exceptionsString = "";
  150.   var bConstructor = false;
  151.   var bPublic = false;
  152.  
  153.   if(languageSignature && methodDescriptor)
  154.   {
  155.     // get the method template
  156.     var isConstructor = methodDescriptor.getAttribute("constructor");
  157.     if(isConstructor && isConstructor == "true")
  158.     {
  159.         bConstructor = true;
  160.     }
  161.     else
  162.     {
  163.         bConstructor = false;
  164.     }
  165.       
  166.     methodTemplate = getMethodTemplate(languageSignature, bConstructor);
  167.  
  168.     // get the throwsSignature
  169.     throwsCall = languageSignature.Throws;
  170.  
  171.     // get info about the method template
  172.     var signatureInfo = getMethodSignatureInfo(methodTemplate);
  173.     var methodCall = null;
  174.     if(bConstructor)
  175.     {
  176.         methodCall = languageSignature.ConstructorDropcode;
  177.     }
  178.     else
  179.     {
  180.         // is there a return value
  181.         var hasReturnValue = false;
  182.         if(methodDescriptor.hasChildNodes())
  183.         {
  184.             var aReturnType = methodDescriptor.getElementsByTagName("returntype");
  185.             if(aReturnType && aReturnType.length)
  186.             {
  187.                 var aReturnTypeSig = aReturnType[0].getElementsByTagName("typesignaturedescriptor");
  188.                 if(aReturnTypeSig && aReturnTypeSig.length)
  189.                 {
  190.                     if(aReturnTypeSig[0].type != "VOID")
  191.                     {
  192.                         hasReturnValue = true;
  193.                     }
  194.                 }
  195.             }
  196.         }
  197.         if(hasReturnValue)
  198.         {
  199.             methodCall = languageSignature.Dropcode;
  200.         }
  201.         else
  202.         {
  203.             methodCall = languageSignature.VoidDropcode;
  204.         }
  205.     }
  206.  
  207.     // replace $$METHODNAME token with the type
  208.     var methodNamePattern = /\$\$METHODNAME/g;
  209.     var methodName = methodDescriptor.name;
  210.     methodCall = methodCall.replace(methodNamePattern, methodName);
  211.  
  212.     // replace $$OBJECTNAME token with object name
  213.     if(methodCall.indexOf("$$OBJECTNAME") >= 0)
  214.     {
  215.         if(!objectName || !objectName.length)
  216.         {
  217.             objectName = "anObject";
  218.         }
  219.         var objectNamePattern = /\$\$OBJECTNAME/g;
  220.         methodCall = methodCall.replace(objectNamePattern, objectName);
  221.     }
  222.  
  223.     if(bConstructor)
  224.     {
  225.         // replace $$RETURNVALUE token with split type
  226.         var returnPattern = /\$\$RETURNVALUE/g;
  227.         var returnType = methodName.split(".");
  228.         returnType = returnType[returnType.length - 1];
  229.         methodCall = methodCall.replace(returnPattern, returnType);
  230.     }
  231.  
  232.     if(methodDescriptor.hasChildNodes())
  233.     {
  234.         // iterate through child nodes
  235.       for(var i = 0;i < methodDescriptor.childNodes.length; i++)
  236.       {
  237.         if(methodDescriptor.childNodes[i].tagName == "RETURNTYPE")
  238.         {
  239.             // replace $$RETURNTYPE token with the type
  240.             var returnPattern = /\$\$RETURNTYPE/g;
  241.             var returnType = getTypeSignature(languageSignature, methodDescriptor.childNodes[i].childNodes[0]);
  242.             methodCall = methodCall.replace(returnPattern, returnType);
  243.  
  244.             // replace $$RETURNVALUE token with split type
  245.             if(methodName.indexOf("get") == 0)
  246.             {
  247.                 returnType = methodName.slice(3);
  248.             }
  249.             else
  250.             {
  251.                 returnType = returnType.split(".");
  252.                 returnType = returnType[returnType.length - 1];
  253.             }
  254.             returnPattern = /\$\$RETURNVALUE/g;
  255.             methodCall = methodCall.replace(returnPattern, returnType);
  256.         }
  257.         else if (methodDescriptor.childNodes[i].tagName == "ARGUMENTS")
  258.         {
  259.           if(signatureInfo.hasArgs)
  260.           {
  261.             var BeginBlockComment = languageSignature.BeginBlockComment;
  262.             var EndBlockComment = languageSignature.EndBlockComment;
  263.             var doBlockComment = BeginBlockComment != null &&
  264.                                     BeginBlockComment.length &&
  265.                                     EndBlockComment != null &&
  266.                                     EndBlockComment.length;
  267.             var argNodes = methodDescriptor.childNodes[i].childNodes;
  268.             for(var j = 0; j < argNodes.length; j++)
  269.             {
  270.               var argNode = argNodes[j];
  271.               if(argNode.hasChildNodes())
  272.               {
  273.                 var argsType = getTypeSignature(languageSignature, argNode.childNodes[0]);
  274.                 if (argumentsString.length)
  275.                 {
  276.                   argumentsString += signatureInfo.argSeparator;
  277.                 }
  278.                 if(doBlockComment)
  279.                 {
  280.                   argumentsString += BeginBlockComment;
  281.                 }
  282.                 argumentsString += argsType;
  283.               }
  284.               var argAttrLen = argNode.attributes.length;
  285.               for (var k=0 ; k < argAttrLen; k++)
  286.               {
  287.                 if (argNode.attributes[k].name == "name")
  288.                 {
  289.                   argumentsString += " ";
  290.                   argumentsString += argNode.attributes[k].value;
  291.                   break;
  292.                 }
  293.               }
  294.               if(doBlockComment)
  295.               {
  296.                 argumentsString += EndBlockComment + MM.MSG_CFC_PleasePutAValueHere;
  297.               }
  298.             }
  299.           }
  300.         }
  301.         else if (methodDescriptor.childNodes[i].tagName == "EXCEPTIONS")
  302.         {
  303. /*
  304.           if(signatureInfo.hasExceptions)
  305.           {
  306.             var exceptionNodes = methodDescriptor.childNodes[i].childNodes;
  307.             for(var j = 0; j < exceptionNodes.length; j++)
  308.             {
  309.               var exceptionType = exceptionNodes[j].name;
  310.               if (exceptionsString && exceptionsString.length)
  311.               {
  312.                 exceptionsString += signatureInfo.exceptionSeparator;
  313.               }
  314.               exceptionsString+= exceptionType;
  315.             }
  316.           }
  317. */
  318.         }
  319.       }
  320.  
  321.       if(signatureInfo.hasArgs)
  322.       {
  323.         // replace $$ARGUMENT tokens
  324.         var firstArgIndex = methodCall.indexOf("$$ARGUMENT");
  325.         var lastArgIndex = methodCall.lastIndexOf("$$ARGUMENT");
  326.         if(argumentsString && argumentsString.length)
  327.         {
  328.           var tempstr = methodCall.substring(0,firstArgIndex);
  329.           tempstr += argumentsString;
  330.           tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  331.           methodCall = tempstr;
  332.         }
  333.         else
  334.         {
  335.           var tempstr = methodCall.substring(0,firstArgIndex);
  336.           tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  337.           methodCall = tempstr;
  338.         }
  339.       }
  340.  
  341.       if(signatureInfo.hasExceptions)
  342.       {
  343. /*
  344.         // replace $$EXCEPTION tokens
  345.         var firstExceptionIndex = methodCall.indexOf("$$EXCEPTION");
  346.         var lastExceptionIndex = methodCall.lastIndexOf("$$EXCEPTION");
  347.         var tempstr = methodCall.substring(0, firstExceptionIndex -  1);
  348.         tempstr += methodCall.substring(lastExceptionIndex + 11, methodCall.length);
  349.         methodCall = tempstr;
  350.         // replace $$THROWS token with the type
  351.         var throwPattern = / \$\$THROWS/g;
  352.         methodCall = methodCall.replace(throwPattern, "");
  353. */
  354.       }
  355.     }
  356.     else
  357.     {
  358.       // replace $$ARGUMENT tokens
  359.       if(signatureInfo.hasArgs)
  360.       {
  361.         var firstArgIndex = methodCall.indexOf("$$ARGUMENT");
  362.         var lastArgIndex = methodCall.lastIndexOf("$$ARGUMENT");
  363.         var tempstr = methodCall.substring(0,firstArgIndex);
  364.         tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  365.         methodCall = tempstr;
  366.       }
  367.  
  368.       if(signatureInfo.hasExceptions)
  369.       {
  370. /*
  371.         // replace $$EXCEPTION tokens
  372.         var firstExceptionIndex = methodCall.indexOf("$$EXCEPTION");
  373.         var lastExceptionIndex = methodCall.lastIndexOf("$$EXCEPTION");
  374.         var tempstr = methodCall.substring(0, firstExceptionIndex - 1);
  375.         tempstr += methodCall.substring(lastExceptionIndex + 11, methodCall.length);
  376.         methodCall = tempstr;
  377.         // replace $$THROWS token with the type
  378.         var throwPattern = / \$\$THROWS/g;
  379.         methodCall = methodCall.replace(throwPattern, "");
  380. */
  381.       }
  382.     }
  383.   }
  384.   return dwscripts.trim(methodCall);
  385. }
  386.  
  387. //*-------------------------------------------------------------------
  388. // FUNCTION:
  389. //  getMethodSignatureInfo
  390. //
  391. // DESCRIPTION:
  392. //    returns the actual method signature after substituting all the
  393. //  required tokens that are present
  394. //
  395. // ARGUMENTS:
  396. //    methodTemplate : method template string
  397. //    
  398. // RETURNS:
  399. //   String
  400. //--------------------------------------------------------------------
  401.  
  402. function getMethodSignatureInfo(methodTemplate)
  403. {
  404.   SignatureInfo = new Object();
  405.   SignatureInfo.hasReturn = false;
  406.   SignatureInfo.hasExceptions = false;
  407.   SignatureInfo.exceptionSeparator = "";
  408.   SignatureInfo.hasArgs = false;
  409.   SignatureInfo.beforeArg = "";
  410.   SignatureInfo.betweenArg = "";
  411.   SignatureInfo.afterArg = "";
  412.  
  413.   // determine whether template has a return value
  414.   if(methodTemplate.indexOf("$$RETURNTYPE") >= 0)
  415.   {
  416.     SignatureInfo.hasReturn = true;
  417.   }
  418.  
  419.   // determine whether template has exceptions
  420.   var firstExceptionIndex = methodTemplate.indexOf("$$EXCEPTION");
  421.   if(firstExceptionIndex >= 0)
  422.   {
  423.     SignatureInfo.hasExceptions = true;
  424.     // get the exception separator string
  425.     var lastExceptionIndex = methodTemplate.lastIndexOf("$$EXCEPTION");
  426.     if(lastExceptionIndex >= 0)
  427.     {
  428.       SignatureInfo.exceptionSeparator = methodTemplate.substring(firstExceptionIndex + 11, lastExceptionIndex);
  429.     }
  430.   }
  431.  
  432.   // determine whether template has args
  433.   var firstArgIndex = methodTemplate.indexOf("$$ARGUMENT");
  434.   if(firstArgIndex >= 0)
  435.   {
  436.     SignatureInfo.hasArgs = true;
  437.     // get the arg separator stirng
  438.     var lastArgIndex = methodTemplate.lastIndexOf("$$ARGUMENT");
  439.     SignatureInfo.argSeparator = methodTemplate.substring(firstArgIndex + 10, lastArgIndex);
  440.   }
  441.   return SignatureInfo;
  442. }
  443.  
  444. //*-------------------------------------------------------------------
  445. // FUNCTION:
  446. //  getMethodSignature
  447. //
  448. // DESCRIPTION:
  449. //    returns the final method signature for that method descriptor
  450. //
  451. // ARGUMENTS:
  452. //    languageSignature : language signature string
  453. //  methodDescriptor  : method descriptor string
  454. //    
  455. // RETURNS:
  456. //   String
  457. //--------------------------------------------------------------------
  458.  
  459. function getMethodSignature(languageSignature, methodDescriptor)
  460. {
  461.   var methodInfo = "";
  462.   var methodCall = "";
  463.   var throwsCall = "";
  464.   var argumentsString="";
  465.   var exceptionsString = "";
  466.   var bConstructor = false;
  467.   var bPublic = false;
  468.  
  469.   if(languageSignature && methodDescriptor)
  470.   {
  471.     // get the method template
  472.     for (var i=0 ; i < methodDescriptor.attributes.length; i++)
  473.     {
  474.       if (methodDescriptor.attributes[i].name == "constructor")
  475.       {
  476.         if (methodDescriptor.attributes[i].value == "true")
  477.         {
  478.           bConstructor = true;
  479.         }
  480.         else
  481.         {
  482.           bConstructor = false;
  483.         }
  484.       }
  485.       else if (methodDescriptor.attributes[i].name == "public")
  486.       {
  487.         if (methodDescriptor.attributes[i].value == "true")
  488.         {
  489.           bPublic = true;
  490.         }
  491.       }      
  492.     }
  493.  
  494.     // we are only interested in showing public methods...
  495.     if(bPublic == false)
  496.       return methodInfo;
  497.       
  498.     methodCall = getMethodTemplate(languageSignature, bConstructor);
  499.     // get the throwsSignature
  500.     throwsCall = languageSignature.Throws;
  501.  
  502.     // get info about the method template
  503.     var signatureInfo = getMethodSignatureInfo(methodCall);
  504.  
  505.     // replace $$METHODNAME token with the type
  506.     var methodNamePattern = /\$\$METHODNAME/g;
  507.     var methodName = methodDescriptor.name;
  508.     methodCall = methodCall.replace(methodNamePattern, methodName);
  509.  
  510.     // iterate through child nodes
  511.     if(methodDescriptor.hasChildNodes())
  512.     {
  513.       for(var i = 0;i < methodDescriptor.childNodes.length; i++)
  514.       {
  515.         if(methodDescriptor.childNodes[i].tagName == "RETURNTYPE")
  516.         {
  517.           if(signatureInfo.hasReturn)
  518.           {
  519.             // replace $$RETURNTYPE token with the type
  520.             var returnTypePattern = /\$\$RETURNTYPE/g;
  521.             var returnType = getTypeSignature(languageSignature, methodDescriptor.childNodes[i].childNodes[0]);
  522.             methodCall = methodCall.replace(returnTypePattern, returnType);
  523.           }
  524.         }
  525.         else if (methodDescriptor.childNodes[i].tagName == "ARGUMENTS")
  526.         {
  527.           if(signatureInfo.hasArgs)
  528.           {
  529.             var argNodes = methodDescriptor.childNodes[i].childNodes;
  530.             for(var j = 0; j < argNodes.length; j++)
  531.             {
  532.               var argNode = argNodes[j];
  533.               if(argNode.hasChildNodes())
  534.               {
  535.                 var argsType = getTypeSignature(languageSignature, argNode.childNodes[0]);
  536.                 if (argumentsString.length)
  537.                 {
  538.                   argumentsString += signatureInfo.argSeparator;
  539.                 }
  540.                 argumentsString += argsType;
  541.               }
  542.               var argAttrLen = argNode.attributes.length;
  543.               for (var k=0 ; k < argAttrLen; k++)
  544.               {
  545.                 if (argNode.attributes[k].name == "name")
  546.                 {
  547.                   argumentsString += " ";
  548.                   argumentsString += argNode.attributes[k].value;
  549.                   break;
  550.                 }
  551.               }
  552.             }
  553.           }
  554.         }
  555.         else if (methodDescriptor.childNodes[i].tagName == "EXCEPTIONS")
  556.         {
  557.           if(signatureInfo.hasExceptions)
  558.           {
  559.             var exceptionNodes = methodDescriptor.childNodes[i].childNodes;
  560.             for(var j = 0; j < exceptionNodes.length; j++)
  561.             {
  562.               var exceptionType = exceptionNodes[j].name;
  563.               if (exceptionsString && exceptionsString.length)
  564.               {
  565.                 exceptionsString += signatureInfo.exceptionSeparator;
  566.               }
  567.               exceptionsString+= exceptionType;
  568.             }
  569.           }
  570.         }
  571.       }
  572.  
  573.       if(signatureInfo.hasArgs)
  574.       {
  575.         // replace $$ARGUMENT tokens
  576.         var firstArgIndex = methodCall.indexOf("$$ARGUMENT");
  577.         var lastArgIndex = methodCall.lastIndexOf("$$ARGUMENT");
  578.         if(argumentsString && argumentsString.length)
  579.         {
  580.           var tempstr = methodCall.substring(0,firstArgIndex);
  581.           tempstr += argumentsString;
  582.           tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  583.           methodCall = tempstr;
  584.         }
  585.         else
  586.         {
  587.           var tempstr = methodCall.substring(0,firstArgIndex);
  588.           tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  589.           methodCall = tempstr;
  590.         }
  591.       }
  592.  
  593.       if(signatureInfo.hasExceptions)
  594.       {
  595.         // replace $$EXCEPTION tokens
  596.         var firstExceptionIndex = methodCall.indexOf("$$EXCEPTION");
  597.         var lastExceptionIndex = methodCall.lastIndexOf("$$EXCEPTION");
  598.         if(exceptionsString && exceptionsString.length)
  599.         {
  600.           var tempstr = methodCall.substring(0,firstExceptionIndex);
  601.           tempstr += exceptionsString;
  602.           tempstr += methodCall.substring(lastExceptionIndex + 11, methodCall.length);
  603.           methodCall = tempstr;
  604.           var throwPattern = /\$\$THROWS/g;
  605.           methodCall = methodCall.replace(throwPattern, throwsCall);
  606.         }
  607.         else
  608.         {
  609.           var tempstr = methodCall.substring(0, firstExceptionIndex - 1);
  610.           tempstr += methodCall.substring(lastExceptionIndex + 11, methodCall.length);
  611.           methodCall = tempstr;
  612.           // replace $$THROWS token with the type
  613.           var throwPattern = / \$\$THROWS/g;
  614.           methodCall = methodCall.replace(throwPattern, "");
  615.         }
  616.       }
  617.     }
  618.     else
  619.     {
  620.       // replace $$ARGUMENT tokens
  621.       if(signatureInfo.hasArgs)
  622.       {
  623.         var firstArgIndex = methodCall.indexOf("$$ARGUMENT");
  624.         var lastArgIndex = methodCall.lastIndexOf("$$ARGUMENT");
  625.         var tempstr = methodCall.substring(0,firstArgIndex);
  626.         tempstr += methodCall.substring(lastArgIndex + 10, methodCall.length);
  627.         methodCall = tempstr;
  628.       }
  629.  
  630.       if(signatureInfo.hasExceptions)
  631.       {
  632.         // replace $$EXCEPTION tokens
  633.         var firstExceptionIndex = methodCall.indexOf("$$EXCEPTION");
  634.         var lastExceptionIndex = methodCall.lastIndexOf("$$EXCEPTION");
  635.         var tempstr = methodCall.substring(0, firstExceptionIndex - 1);
  636.         tempstr += methodCall.substring(lastExceptionIndex + 11, methodCall.length);
  637.         methodCall = tempstr;
  638.         // replace $$THROWS token with the type
  639.         var throwPattern = / \$\$THROWS/g;
  640.         methodCall = methodCall.replace(throwPattern, "");
  641.         //return methodCall;
  642.       }
  643.     }
  644.   }
  645.  
  646.   if(bPublic)
  647.     methodInfo = "public ";
  648.   methodInfo += methodCall;  
  649.   return methodInfo;
  650. }
  651.  
  652. //*-------------------------------------------------------------------
  653. // FUNCTION:
  654. //  getPropertySignature
  655. //
  656. // DESCRIPTION:
  657. //    returns the final Property signature for that descriptor
  658. //
  659. // ARGUMENTS:
  660. //    languageSignature   : language signature string
  661. //  propertyDescriptor  : Property descriptor string
  662. //    
  663. // RETURNS:
  664. //   String
  665. //--------------------------------------------------------------------
  666.  
  667. function getPropertySignature(languageSignature, propertyDescriptor)
  668. {
  669.   var propertySignature = "";
  670.   var type = "";
  671.  
  672.   if (languageSignature && propertyDescriptor)
  673.   {
  674.       var typeSignatureDescriptor = propertyDescriptor.childNodes[0].childNodes[0];
  675.       if (typeSignatureDescriptor)
  676.       {
  677.         type += getTypeSignature(languageSignature, typeSignatureDescriptor);
  678.       }
  679.  
  680.     if (propertyDescriptor) 
  681.     {
  682.       var bPublic = false;
  683.       for (var i=0 ; i < propertyDescriptor.attributes.length; i++)
  684.       {
  685.         if (propertyDescriptor.attributes[i].name == "public")
  686.         {
  687.           // we are only interested in showing public properties
  688.           if (propertyDescriptor.attributes[i].value == "true")
  689.           {
  690.             bPublic = true;
  691.           }
  692.           break;
  693.         }
  694.       }
  695.  
  696.     
  697.       if(bPublic == true)
  698.         propertySignature += "public";
  699.       else
  700.         return propertySignature;
  701.  
  702.       if(propertyDescriptor.name)
  703.         propertySignature += " " + propertyDescriptor.name;
  704.       if(type)
  705.           propertySignature += ", " + type;  
  706.           
  707.       //if(propertyDescriptor.value)
  708.       //  propertySignature += "=" + propertyDescriptor.value;  
  709.     }  
  710.   }  
  711.  
  712.   return propertySignature;
  713. }
  714.  
  715. //*-------------------------------------------------------------------
  716. // FUNCTION:
  717. //  getFieldSignature
  718. //
  719. // DESCRIPTION:
  720. //    returns the final Field signature for that descriptor
  721. //
  722. // ARGUMENTS:
  723. //    languageSignature : language signature string
  724. //  fieldDescriptor   : field descriptor string
  725. //    
  726. // RETURNS:
  727. //   String
  728. //--------------------------------------------------------------------
  729.  
  730. function getFieldSignature(languageSignature, fieldDescriptor)
  731. {
  732.   var fieldSignature = "";
  733.   var type = "";
  734.  
  735.   if (languageSignature && fieldDescriptor)
  736.   {
  737.       var typeSignatureDescriptor = fieldDescriptor.childNodes[0].childNodes[0];
  738.       if (typeSignatureDescriptor)
  739.       {
  740.         type += getTypeSignature(languageSignature, typeSignatureDescriptor);
  741.       }
  742.  
  743.     if (fieldDescriptor) 
  744.     {
  745.       var bPublic = false;
  746.       for (var i=0 ; i < fieldDescriptor.attributes.length; i++)
  747.       {
  748.         if (fieldDescriptor.attributes[i].name == "public")
  749.         {
  750.           if (fieldDescriptor.attributes[i].value == "true")
  751.           {
  752.             bPublic = true;
  753.           }
  754.           break;
  755.         }
  756.       }
  757.  
  758.       // we are only interested in showing public fields...    
  759.       if(bPublic == true)
  760.         fieldSignature += "public";
  761.       else
  762.         return fieldSignature;  
  763.       if(fieldDescriptor.name)
  764.         fieldSignature += " " + fieldDescriptor.name;
  765.       if(type)
  766.           fieldSignature += ", " + type;  
  767.         
  768.       //if(fieldDescriptor.value)
  769.       //  fieldSignature += "=" + fieldDescriptor.value;  
  770.     }  
  771.   }  
  772.  
  773.   return fieldSignature;
  774. }
  775.